import java.util.*;


public class day2 {
    /**
     *  WY6 合唱团
     *  https://www.nowcoder.com/practice/661c49118ca241909add3a11c96408c8?tpId=122&tqId=33652&ru=/exam/oj
     */
    public static int N = 51,K = 11;

    public static int n,k,d;
    public static long[] arr = new long[N];// 存储能力值
    // f[i][j]: 表示从[1,i]区间挑选，挑选j个人，最后一个人必选，此时的最大乘积
    public static long[][] f = new long[N][K];
    // g[i][j]: 表示从[1,i]区间挑选，挑选j个人，最后一个人必选，此时的最小乘积
    public static long[][] g = new long[N][K]; // 因为arr[i]这个值，可能存在负数，所以需要一个小的乘积和其相乘得到大的值

    public static void main3(String[] args) {
        Scanner in = new Scanner(System.in);
        n = in.nextInt();
        for(int i = 1;i <= n;i++) {
            arr[i] = in.nextInt();
        }
        k = in.nextInt();
        d = in.nextInt();

        // 初始化，因为这个j不能大于i的值，否则是无效的，所以只需要管理对角线即左下角值即可
        // 线性dp
        for(int i = 1;i <= n;i++) {
            // 这里在这里就可以初始化
            // 当j为1的时候，i不沦为多少，那么这个位置的dp值一定为对应的能力值
            f[i][1] = g[i][1] = arr[i];
            // 这里的Math.min(k,i) 是为了防止j大于i，计算无效的值
            for(int j = 2;j <= Math.min(k,i);j++) { // 挑选j 个人
                // 把对应的dp位置值进行初始化
                f[i][j] = Long.MIN_VALUE;
                g[i][j] = Long.MAX_VALUE;
                // 因为选择和i位置相邻的位置的人选，需要满足i-(prev) <= d => prev >= i - d
                // 并且还需要满足一个条件，就是 prev >= j - 1 (这里因为最后一位必选，所以减一)
                // 所需要选的人数得满足 j-1 的个数，比如：不能是 prev为3，但是j-1 为5
                // 这样就是在 Math.max(i-d，j-1) <= prev < i 区间进行寻找最大的乘积
                for(int prev = Math.max(i - d,j - 1); prev < i;prev++) {
                    f[i][j] = Math.max(f[i][j],Math.max(f[prev][j - 1] * arr[i],g[prev][j - 1] * arr[i]));
                    g[i][j] = Math.min(g[i][j],Math.min(f[prev][j - 1] * arr[i],g[prev][j - 1] * arr[i]));
                }
            }
        }

        // 返回值
        // 需要返回 f[n][k] ~ f[k][k] 区间的最大值，因为我们也不知道最大值在哪里出现的，所以需要遍历一遍
        long ret = Long.MIN_VALUE;
        for(int i = k;i <= n;i++) {
            ret = Math.max(ret,f[i][k]);
        }

        System.out.println(ret);
    }




    /**
     * AB31 活动安排
     * https://www.nowcoder.com/practice/16d971e9e42e4f3b9b1e2b8794796a43?tpId=308&tqId=40488&ru=/exam/oj
     */
    public static void main2(String[] args) {
        Scanner in = new Scanner(System.in);
        // 区间贪心
        int n = in.nextInt();
        int[][] arr = new int[n][2];
        for(int i = 0;i < n;i++) {
            arr[i][0] = in.nextInt();
            arr[i][1] = in.nextInt();
        }

        // 根据左端点进行排序，升序排序
        Arrays.sort(arr,(v1,v2) -> {
            return v1[0] <= v2[0] ? -1 : 1;
        });

        // 进行贪心操作
        int ret = 1,b = arr[0][1];
        for(int i = 1;i < n;i++) {
            int a1 = arr[i][0],b1 = arr[i][1];
            if(a1 < b) {
                // 存在重叠
                // 把 b 更新为最小的那个
                b = Math.min(b,b1);
            }else {
                // 无重叠
                // 个数+1，并且把b更新为新的区间上去
                ret++;
                b = b1;
            }
        }
        System.out.println(ret);
    }



    /**
     * BC157 素数回文
     * https://www.nowcoder.com/practice/d638855898fb4d22bc0ae9314fed956f?tpId=290&tqId=39945&ru=/exam/oj
     */
    public static void main1(String[] args) {
        Scanner in = new Scanner(System.in);
        String s = in.next();
        // 先将其转化为回文串
        long x = change(s);
        // 进行判断
        if(isprime(x)) {
            System.out.println("prime");
        }else {
            System.out.println("noprime");
        }
    }

    public static long change(String s) {
        StringBuffer ret = new StringBuffer();
        ret.append(s);
        for(int i = s.length() - 2;i >= 0;i--) {
            ret.append(s.charAt(i));
        }
        return Long.parseLong(ret.toString());
    }

    public static boolean isprime(long x) {
        if(x <= 1) {
            return false;
        }
        for(int i = 2;i <= Math.sqrt(x);i++) {
            if(x % i == 0) {
                return false;
            }
        }
        return true;
    }
}
